/* -*-c++-*- OpenRTI - Copyright (C) 2009-2023 Mathias Froehlich
 *
 *
 * This file is part of OpenRTI.
 *
 * OpenRTI is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * OpenRTI is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with OpenRTI.  If not, see <http://www.gnu.org/licenses/>.
 *
 * This file is autogenerated by messagegen.py. Do not edit!
 *
 */


#include "Message.h"

#include <ostream>
#include "AbstractMessage.h"
#include "AbstractMessageDispatcher.h"
#include "StringUtils.h"

namespace OpenRTI {

ConnectionLostMessage::ConnectionLostMessage() :
  _faultDescription()
{
}

ConnectionLostMessage::~ConnectionLostMessage()
{
}

const char*
ConnectionLostMessage::getTypeName() const
{
  return "ConnectionLostMessage";
}

void
ConnectionLostMessage::out(std::ostream& os) const
{
  os << "ConnectionLostMessage " << *this;
}

void
ConnectionLostMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ConnectionLostMessage::operator==(const AbstractMessage& rhs) const
{
  const ConnectionLostMessage* message = dynamic_cast<const ConnectionLostMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ConnectionLostMessage::operator==(const ConnectionLostMessage& rhs) const
{
  if (getFaultDescription() != rhs.getFaultDescription()) return false;
  return true;
}

bool
ConnectionLostMessage::operator<(const ConnectionLostMessage& rhs) const
{
  if (getFaultDescription() < rhs.getFaultDescription()) return true;
  if (rhs.getFaultDescription() < getFaultDescription()) return false;
  return false;
}

CreateFederationExecutionRequestMessage::CreateFederationExecutionRequestMessage() :
  _federationExecution(),
  _logicalTimeFactoryName(),
  _fOMStringModuleList()
{
}

CreateFederationExecutionRequestMessage::~CreateFederationExecutionRequestMessage()
{
}

const char*
CreateFederationExecutionRequestMessage::getTypeName() const
{
  return "CreateFederationExecutionRequestMessage";
}

void
CreateFederationExecutionRequestMessage::out(std::ostream& os) const
{
  os << "CreateFederationExecutionRequestMessage " << *this;
}

void
CreateFederationExecutionRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
CreateFederationExecutionRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const CreateFederationExecutionRequestMessage* message = dynamic_cast<const CreateFederationExecutionRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
CreateFederationExecutionRequestMessage::operator==(const CreateFederationExecutionRequestMessage& rhs) const
{
  if (getFederationExecution() != rhs.getFederationExecution()) return false;
  if (getLogicalTimeFactoryName() != rhs.getLogicalTimeFactoryName()) return false;
  if (getFOMStringModuleList() != rhs.getFOMStringModuleList()) return false;
  return true;
}

bool
CreateFederationExecutionRequestMessage::operator<(const CreateFederationExecutionRequestMessage& rhs) const
{
  if (getFederationExecution() < rhs.getFederationExecution()) return true;
  if (rhs.getFederationExecution() < getFederationExecution()) return false;
  if (getLogicalTimeFactoryName() < rhs.getLogicalTimeFactoryName()) return true;
  if (rhs.getLogicalTimeFactoryName() < getLogicalTimeFactoryName()) return false;
  if (getFOMStringModuleList() < rhs.getFOMStringModuleList()) return true;
  if (rhs.getFOMStringModuleList() < getFOMStringModuleList()) return false;
  return false;
}

CreateFederationExecutionResponseMessage::CreateFederationExecutionResponseMessage() :
  _createFederationExecutionResponseType(),
  _exceptionString()
{
}

CreateFederationExecutionResponseMessage::~CreateFederationExecutionResponseMessage()
{
}

const char*
CreateFederationExecutionResponseMessage::getTypeName() const
{
  return "CreateFederationExecutionResponseMessage";
}

void
CreateFederationExecutionResponseMessage::out(std::ostream& os) const
{
  os << "CreateFederationExecutionResponseMessage " << *this;
}

void
CreateFederationExecutionResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
CreateFederationExecutionResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const CreateFederationExecutionResponseMessage* message = dynamic_cast<const CreateFederationExecutionResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
CreateFederationExecutionResponseMessage::operator==(const CreateFederationExecutionResponseMessage& rhs) const
{
  if (getCreateFederationExecutionResponseType() != rhs.getCreateFederationExecutionResponseType()) return false;
  if (getExceptionString() != rhs.getExceptionString()) return false;
  return true;
}

bool
CreateFederationExecutionResponseMessage::operator<(const CreateFederationExecutionResponseMessage& rhs) const
{
  if (getCreateFederationExecutionResponseType() < rhs.getCreateFederationExecutionResponseType()) return true;
  if (rhs.getCreateFederationExecutionResponseType() < getCreateFederationExecutionResponseType()) return false;
  if (getExceptionString() < rhs.getExceptionString()) return true;
  if (rhs.getExceptionString() < getExceptionString()) return false;
  return false;
}

DestroyFederationExecutionRequestMessage::DestroyFederationExecutionRequestMessage() :
  _federationExecution()
{
}

DestroyFederationExecutionRequestMessage::~DestroyFederationExecutionRequestMessage()
{
}

const char*
DestroyFederationExecutionRequestMessage::getTypeName() const
{
  return "DestroyFederationExecutionRequestMessage";
}

void
DestroyFederationExecutionRequestMessage::out(std::ostream& os) const
{
  os << "DestroyFederationExecutionRequestMessage " << *this;
}

void
DestroyFederationExecutionRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
DestroyFederationExecutionRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const DestroyFederationExecutionRequestMessage* message = dynamic_cast<const DestroyFederationExecutionRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
DestroyFederationExecutionRequestMessage::operator==(const DestroyFederationExecutionRequestMessage& rhs) const
{
  if (getFederationExecution() != rhs.getFederationExecution()) return false;
  return true;
}

bool
DestroyFederationExecutionRequestMessage::operator<(const DestroyFederationExecutionRequestMessage& rhs) const
{
  if (getFederationExecution() < rhs.getFederationExecution()) return true;
  if (rhs.getFederationExecution() < getFederationExecution()) return false;
  return false;
}

DestroyFederationExecutionResponseMessage::DestroyFederationExecutionResponseMessage() :
  _destroyFederationExecutionResponseType()
{
}

DestroyFederationExecutionResponseMessage::~DestroyFederationExecutionResponseMessage()
{
}

const char*
DestroyFederationExecutionResponseMessage::getTypeName() const
{
  return "DestroyFederationExecutionResponseMessage";
}

void
DestroyFederationExecutionResponseMessage::out(std::ostream& os) const
{
  os << "DestroyFederationExecutionResponseMessage " << *this;
}

void
DestroyFederationExecutionResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
DestroyFederationExecutionResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const DestroyFederationExecutionResponseMessage* message = dynamic_cast<const DestroyFederationExecutionResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
DestroyFederationExecutionResponseMessage::operator==(const DestroyFederationExecutionResponseMessage& rhs) const
{
  if (getDestroyFederationExecutionResponseType() != rhs.getDestroyFederationExecutionResponseType()) return false;
  return true;
}

bool
DestroyFederationExecutionResponseMessage::operator<(const DestroyFederationExecutionResponseMessage& rhs) const
{
  if (getDestroyFederationExecutionResponseType() < rhs.getDestroyFederationExecutionResponseType()) return true;
  if (rhs.getDestroyFederationExecutionResponseType() < getDestroyFederationExecutionResponseType()) return false;
  return false;
}

EnumerateFederationExecutionsRequestMessage::EnumerateFederationExecutionsRequestMessage()
{
}

EnumerateFederationExecutionsRequestMessage::~EnumerateFederationExecutionsRequestMessage()
{
}

const char*
EnumerateFederationExecutionsRequestMessage::getTypeName() const
{
  return "EnumerateFederationExecutionsRequestMessage";
}

void
EnumerateFederationExecutionsRequestMessage::out(std::ostream& os) const
{
  os << "EnumerateFederationExecutionsRequestMessage " << *this;
}

void
EnumerateFederationExecutionsRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
EnumerateFederationExecutionsRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const EnumerateFederationExecutionsRequestMessage* message = dynamic_cast<const EnumerateFederationExecutionsRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
EnumerateFederationExecutionsRequestMessage::operator==(const EnumerateFederationExecutionsRequestMessage& rhs) const
{
  return true;
}

bool
EnumerateFederationExecutionsRequestMessage::operator<(const EnumerateFederationExecutionsRequestMessage& rhs) const
{
  return false;
}

EnumerateFederationExecutionsResponseMessage::EnumerateFederationExecutionsResponseMessage() :
  _federationExecutionInformationVector()
{
}

EnumerateFederationExecutionsResponseMessage::~EnumerateFederationExecutionsResponseMessage()
{
}

const char*
EnumerateFederationExecutionsResponseMessage::getTypeName() const
{
  return "EnumerateFederationExecutionsResponseMessage";
}

void
EnumerateFederationExecutionsResponseMessage::out(std::ostream& os) const
{
  os << "EnumerateFederationExecutionsResponseMessage " << *this;
}

void
EnumerateFederationExecutionsResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
EnumerateFederationExecutionsResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const EnumerateFederationExecutionsResponseMessage* message = dynamic_cast<const EnumerateFederationExecutionsResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
EnumerateFederationExecutionsResponseMessage::operator==(const EnumerateFederationExecutionsResponseMessage& rhs) const
{
  if (getFederationExecutionInformationVector() != rhs.getFederationExecutionInformationVector()) return false;
  return true;
}

bool
EnumerateFederationExecutionsResponseMessage::operator<(const EnumerateFederationExecutionsResponseMessage& rhs) const
{
  if (getFederationExecutionInformationVector() < rhs.getFederationExecutionInformationVector()) return true;
  if (rhs.getFederationExecutionInformationVector() < getFederationExecutionInformationVector()) return false;
  return false;
}

InsertFederationExecutionMessage::InsertFederationExecutionMessage() :
  _federationHandle(),
  _federationName(),
  _logicalTimeFactoryName(),
  _configurationParameterMap()
{
}

InsertFederationExecutionMessage::~InsertFederationExecutionMessage()
{
}

const char*
InsertFederationExecutionMessage::getTypeName() const
{
  return "InsertFederationExecutionMessage";
}

void
InsertFederationExecutionMessage::out(std::ostream& os) const
{
  os << "InsertFederationExecutionMessage " << *this;
}

void
InsertFederationExecutionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
InsertFederationExecutionMessage::operator==(const AbstractMessage& rhs) const
{
  const InsertFederationExecutionMessage* message = dynamic_cast<const InsertFederationExecutionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
InsertFederationExecutionMessage::operator==(const InsertFederationExecutionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederationName() != rhs.getFederationName()) return false;
  if (getLogicalTimeFactoryName() != rhs.getLogicalTimeFactoryName()) return false;
  if (getConfigurationParameterMap() != rhs.getConfigurationParameterMap()) return false;
  return true;
}

bool
InsertFederationExecutionMessage::operator<(const InsertFederationExecutionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederationName() < rhs.getFederationName()) return true;
  if (rhs.getFederationName() < getFederationName()) return false;
  if (getLogicalTimeFactoryName() < rhs.getLogicalTimeFactoryName()) return true;
  if (rhs.getLogicalTimeFactoryName() < getLogicalTimeFactoryName()) return false;
  if (getConfigurationParameterMap() < rhs.getConfigurationParameterMap()) return true;
  if (rhs.getConfigurationParameterMap() < getConfigurationParameterMap()) return false;
  return false;
}

ShutdownFederationExecutionMessage::ShutdownFederationExecutionMessage() :
  _federationHandle()
{
}

ShutdownFederationExecutionMessage::~ShutdownFederationExecutionMessage()
{
}

const char*
ShutdownFederationExecutionMessage::getTypeName() const
{
  return "ShutdownFederationExecutionMessage";
}

void
ShutdownFederationExecutionMessage::out(std::ostream& os) const
{
  os << "ShutdownFederationExecutionMessage " << *this;
}

void
ShutdownFederationExecutionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ShutdownFederationExecutionMessage::operator==(const AbstractMessage& rhs) const
{
  const ShutdownFederationExecutionMessage* message = dynamic_cast<const ShutdownFederationExecutionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ShutdownFederationExecutionMessage::operator==(const ShutdownFederationExecutionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  return true;
}

bool
ShutdownFederationExecutionMessage::operator<(const ShutdownFederationExecutionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  return false;
}

EraseFederationExecutionMessage::EraseFederationExecutionMessage() :
  _federationHandle()
{
}

EraseFederationExecutionMessage::~EraseFederationExecutionMessage()
{
}

const char*
EraseFederationExecutionMessage::getTypeName() const
{
  return "EraseFederationExecutionMessage";
}

void
EraseFederationExecutionMessage::out(std::ostream& os) const
{
  os << "EraseFederationExecutionMessage " << *this;
}

void
EraseFederationExecutionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
EraseFederationExecutionMessage::operator==(const AbstractMessage& rhs) const
{
  const EraseFederationExecutionMessage* message = dynamic_cast<const EraseFederationExecutionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
EraseFederationExecutionMessage::operator==(const EraseFederationExecutionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  return true;
}

bool
EraseFederationExecutionMessage::operator<(const EraseFederationExecutionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  return false;
}

ReleaseFederationHandleMessage::ReleaseFederationHandleMessage() :
  _federationHandle()
{
}

ReleaseFederationHandleMessage::~ReleaseFederationHandleMessage()
{
}

const char*
ReleaseFederationHandleMessage::getTypeName() const
{
  return "ReleaseFederationHandleMessage";
}

void
ReleaseFederationHandleMessage::out(std::ostream& os) const
{
  os << "ReleaseFederationHandleMessage " << *this;
}

void
ReleaseFederationHandleMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ReleaseFederationHandleMessage::operator==(const AbstractMessage& rhs) const
{
  const ReleaseFederationHandleMessage* message = dynamic_cast<const ReleaseFederationHandleMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ReleaseFederationHandleMessage::operator==(const ReleaseFederationHandleMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  return true;
}

bool
ReleaseFederationHandleMessage::operator<(const ReleaseFederationHandleMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  return false;
}

InsertModulesMessage::InsertModulesMessage() :
  _federationHandle(),
  _fOMModuleList()
{
}

InsertModulesMessage::~InsertModulesMessage()
{
}

const char*
InsertModulesMessage::getTypeName() const
{
  return "InsertModulesMessage";
}

void
InsertModulesMessage::out(std::ostream& os) const
{
  os << "InsertModulesMessage " << *this;
}

void
InsertModulesMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
InsertModulesMessage::operator==(const AbstractMessage& rhs) const
{
  const InsertModulesMessage* message = dynamic_cast<const InsertModulesMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
InsertModulesMessage::operator==(const InsertModulesMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFOMModuleList() != rhs.getFOMModuleList()) return false;
  return true;
}

bool
InsertModulesMessage::operator<(const InsertModulesMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFOMModuleList() < rhs.getFOMModuleList()) return true;
  if (rhs.getFOMModuleList() < getFOMModuleList()) return false;
  return false;
}

JoinFederationExecutionRequestMessage::JoinFederationExecutionRequestMessage() :
  _federationExecution(),
  _federateType(),
  _federateName(),
  _fOMStringModuleList(),
  _configurationParameterMap()
{
}

JoinFederationExecutionRequestMessage::~JoinFederationExecutionRequestMessage()
{
}

const char*
JoinFederationExecutionRequestMessage::getTypeName() const
{
  return "JoinFederationExecutionRequestMessage";
}

void
JoinFederationExecutionRequestMessage::out(std::ostream& os) const
{
  os << "JoinFederationExecutionRequestMessage " << *this;
}

void
JoinFederationExecutionRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
JoinFederationExecutionRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const JoinFederationExecutionRequestMessage* message = dynamic_cast<const JoinFederationExecutionRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
JoinFederationExecutionRequestMessage::operator==(const JoinFederationExecutionRequestMessage& rhs) const
{
  if (getFederationExecution() != rhs.getFederationExecution()) return false;
  if (getFederateType() != rhs.getFederateType()) return false;
  if (getFederateName() != rhs.getFederateName()) return false;
  if (getFOMStringModuleList() != rhs.getFOMStringModuleList()) return false;
  if (getConfigurationParameterMap() != rhs.getConfigurationParameterMap()) return false;
  return true;
}

bool
JoinFederationExecutionRequestMessage::operator<(const JoinFederationExecutionRequestMessage& rhs) const
{
  if (getFederationExecution() < rhs.getFederationExecution()) return true;
  if (rhs.getFederationExecution() < getFederationExecution()) return false;
  if (getFederateType() < rhs.getFederateType()) return true;
  if (rhs.getFederateType() < getFederateType()) return false;
  if (getFederateName() < rhs.getFederateName()) return true;
  if (rhs.getFederateName() < getFederateName()) return false;
  if (getFOMStringModuleList() < rhs.getFOMStringModuleList()) return true;
  if (rhs.getFOMStringModuleList() < getFOMStringModuleList()) return false;
  if (getConfigurationParameterMap() < rhs.getConfigurationParameterMap()) return true;
  if (rhs.getConfigurationParameterMap() < getConfigurationParameterMap()) return false;
  return false;
}

JoinFederationExecutionResponseMessage::JoinFederationExecutionResponseMessage() :
  _federationHandle(),
  _joinFederationExecutionResponseType(),
  _exceptionString(),
  _federateHandle(),
  _federateType(),
  _federateName()
{
}

JoinFederationExecutionResponseMessage::~JoinFederationExecutionResponseMessage()
{
}

const char*
JoinFederationExecutionResponseMessage::getTypeName() const
{
  return "JoinFederationExecutionResponseMessage";
}

void
JoinFederationExecutionResponseMessage::out(std::ostream& os) const
{
  os << "JoinFederationExecutionResponseMessage " << *this;
}

void
JoinFederationExecutionResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
JoinFederationExecutionResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const JoinFederationExecutionResponseMessage* message = dynamic_cast<const JoinFederationExecutionResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
JoinFederationExecutionResponseMessage::operator==(const JoinFederationExecutionResponseMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getJoinFederationExecutionResponseType() != rhs.getJoinFederationExecutionResponseType()) return false;
  if (getExceptionString() != rhs.getExceptionString()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getFederateType() != rhs.getFederateType()) return false;
  if (getFederateName() != rhs.getFederateName()) return false;
  return true;
}

bool
JoinFederationExecutionResponseMessage::operator<(const JoinFederationExecutionResponseMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getJoinFederationExecutionResponseType() < rhs.getJoinFederationExecutionResponseType()) return true;
  if (rhs.getJoinFederationExecutionResponseType() < getJoinFederationExecutionResponseType()) return false;
  if (getExceptionString() < rhs.getExceptionString()) return true;
  if (rhs.getExceptionString() < getExceptionString()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getFederateType() < rhs.getFederateType()) return true;
  if (rhs.getFederateType() < getFederateType()) return false;
  if (getFederateName() < rhs.getFederateName()) return true;
  if (rhs.getFederateName() < getFederateName()) return false;
  return false;
}

ResignFederationExecutionLeafRequestMessage::ResignFederationExecutionLeafRequestMessage() :
  _federationHandle(),
  _federateHandle(),
  _resignAction()
{
}

ResignFederationExecutionLeafRequestMessage::~ResignFederationExecutionLeafRequestMessage()
{
}

const char*
ResignFederationExecutionLeafRequestMessage::getTypeName() const
{
  return "ResignFederationExecutionLeafRequestMessage";
}

void
ResignFederationExecutionLeafRequestMessage::out(std::ostream& os) const
{
  os << "ResignFederationExecutionLeafRequestMessage " << *this;
}

void
ResignFederationExecutionLeafRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ResignFederationExecutionLeafRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const ResignFederationExecutionLeafRequestMessage* message = dynamic_cast<const ResignFederationExecutionLeafRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ResignFederationExecutionLeafRequestMessage::operator==(const ResignFederationExecutionLeafRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getResignAction() != rhs.getResignAction()) return false;
  return true;
}

bool
ResignFederationExecutionLeafRequestMessage::operator<(const ResignFederationExecutionLeafRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getResignAction() < rhs.getResignAction()) return true;
  if (rhs.getResignAction() < getResignAction()) return false;
  return false;
}

ResignFederationExecutionRequestMessage::ResignFederationExecutionRequestMessage() :
  _federationHandle(),
  _federateHandle()
{
}

ResignFederationExecutionRequestMessage::~ResignFederationExecutionRequestMessage()
{
}

const char*
ResignFederationExecutionRequestMessage::getTypeName() const
{
  return "ResignFederationExecutionRequestMessage";
}

void
ResignFederationExecutionRequestMessage::out(std::ostream& os) const
{
  os << "ResignFederationExecutionRequestMessage " << *this;
}

void
ResignFederationExecutionRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ResignFederationExecutionRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const ResignFederationExecutionRequestMessage* message = dynamic_cast<const ResignFederationExecutionRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ResignFederationExecutionRequestMessage::operator==(const ResignFederationExecutionRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  return true;
}

bool
ResignFederationExecutionRequestMessage::operator<(const ResignFederationExecutionRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  return false;
}

JoinFederateNotifyMessage::JoinFederateNotifyMessage() :
  _federationHandle(),
  _federateHandle(),
  _federateType(),
  _federateName()
{
}

JoinFederateNotifyMessage::~JoinFederateNotifyMessage()
{
}

const char*
JoinFederateNotifyMessage::getTypeName() const
{
  return "JoinFederateNotifyMessage";
}

void
JoinFederateNotifyMessage::out(std::ostream& os) const
{
  os << "JoinFederateNotifyMessage " << *this;
}

void
JoinFederateNotifyMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
JoinFederateNotifyMessage::operator==(const AbstractMessage& rhs) const
{
  const JoinFederateNotifyMessage* message = dynamic_cast<const JoinFederateNotifyMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
JoinFederateNotifyMessage::operator==(const JoinFederateNotifyMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getFederateType() != rhs.getFederateType()) return false;
  if (getFederateName() != rhs.getFederateName()) return false;
  return true;
}

bool
JoinFederateNotifyMessage::operator<(const JoinFederateNotifyMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getFederateType() < rhs.getFederateType()) return true;
  if (rhs.getFederateType() < getFederateType()) return false;
  if (getFederateName() < rhs.getFederateName()) return true;
  if (rhs.getFederateName() < getFederateName()) return false;
  return false;
}

ResignFederateNotifyMessage::ResignFederateNotifyMessage() :
  _federationHandle(),
  _federateHandle()
{
}

ResignFederateNotifyMessage::~ResignFederateNotifyMessage()
{
}

const char*
ResignFederateNotifyMessage::getTypeName() const
{
  return "ResignFederateNotifyMessage";
}

void
ResignFederateNotifyMessage::out(std::ostream& os) const
{
  os << "ResignFederateNotifyMessage " << *this;
}

void
ResignFederateNotifyMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ResignFederateNotifyMessage::operator==(const AbstractMessage& rhs) const
{
  const ResignFederateNotifyMessage* message = dynamic_cast<const ResignFederateNotifyMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ResignFederateNotifyMessage::operator==(const ResignFederateNotifyMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  return true;
}

bool
ResignFederateNotifyMessage::operator<(const ResignFederateNotifyMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  return false;
}

ChangeAutomaticResignDirectiveMessage::ChangeAutomaticResignDirectiveMessage() :
  _federationHandle(),
  _federateHandle(),
  _resignAction()
{
}

ChangeAutomaticResignDirectiveMessage::~ChangeAutomaticResignDirectiveMessage()
{
}

const char*
ChangeAutomaticResignDirectiveMessage::getTypeName() const
{
  return "ChangeAutomaticResignDirectiveMessage";
}

void
ChangeAutomaticResignDirectiveMessage::out(std::ostream& os) const
{
  os << "ChangeAutomaticResignDirectiveMessage " << *this;
}

void
ChangeAutomaticResignDirectiveMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ChangeAutomaticResignDirectiveMessage::operator==(const AbstractMessage& rhs) const
{
  const ChangeAutomaticResignDirectiveMessage* message = dynamic_cast<const ChangeAutomaticResignDirectiveMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ChangeAutomaticResignDirectiveMessage::operator==(const ChangeAutomaticResignDirectiveMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getResignAction() != rhs.getResignAction()) return false;
  return true;
}

bool
ChangeAutomaticResignDirectiveMessage::operator<(const ChangeAutomaticResignDirectiveMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getResignAction() < rhs.getResignAction()) return true;
  if (rhs.getResignAction() < getResignAction()) return false;
  return false;
}

RegisterFederationSynchronizationPointMessage::RegisterFederationSynchronizationPointMessage() :
  _federationHandle(),
  _federateHandle(),
  _label(),
  _tag(),
  _federateHandleVector()
{
}

RegisterFederationSynchronizationPointMessage::~RegisterFederationSynchronizationPointMessage()
{
}

const char*
RegisterFederationSynchronizationPointMessage::getTypeName() const
{
  return "RegisterFederationSynchronizationPointMessage";
}

void
RegisterFederationSynchronizationPointMessage::out(std::ostream& os) const
{
  os << "RegisterFederationSynchronizationPointMessage " << *this;
}

void
RegisterFederationSynchronizationPointMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
RegisterFederationSynchronizationPointMessage::operator==(const AbstractMessage& rhs) const
{
  const RegisterFederationSynchronizationPointMessage* message = dynamic_cast<const RegisterFederationSynchronizationPointMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
RegisterFederationSynchronizationPointMessage::operator==(const RegisterFederationSynchronizationPointMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getLabel() != rhs.getLabel()) return false;
  if (getTag() != rhs.getTag()) return false;
  if (getFederateHandleVector() != rhs.getFederateHandleVector()) return false;
  return true;
}

bool
RegisterFederationSynchronizationPointMessage::operator<(const RegisterFederationSynchronizationPointMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getLabel() < rhs.getLabel()) return true;
  if (rhs.getLabel() < getLabel()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  if (getFederateHandleVector() < rhs.getFederateHandleVector()) return true;
  if (rhs.getFederateHandleVector() < getFederateHandleVector()) return false;
  return false;
}

RegisterFederationSynchronizationPointResponseMessage::RegisterFederationSynchronizationPointResponseMessage() :
  _federationHandle(),
  _federateHandle(),
  _label(),
  _registerFederationSynchronizationPointResponseType()
{
}

RegisterFederationSynchronizationPointResponseMessage::~RegisterFederationSynchronizationPointResponseMessage()
{
}

const char*
RegisterFederationSynchronizationPointResponseMessage::getTypeName() const
{
  return "RegisterFederationSynchronizationPointResponseMessage";
}

void
RegisterFederationSynchronizationPointResponseMessage::out(std::ostream& os) const
{
  os << "RegisterFederationSynchronizationPointResponseMessage " << *this;
}

void
RegisterFederationSynchronizationPointResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
RegisterFederationSynchronizationPointResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const RegisterFederationSynchronizationPointResponseMessage* message = dynamic_cast<const RegisterFederationSynchronizationPointResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
RegisterFederationSynchronizationPointResponseMessage::operator==(const RegisterFederationSynchronizationPointResponseMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getLabel() != rhs.getLabel()) return false;
  if (getRegisterFederationSynchronizationPointResponseType() != rhs.getRegisterFederationSynchronizationPointResponseType()) return false;
  return true;
}

bool
RegisterFederationSynchronizationPointResponseMessage::operator<(const RegisterFederationSynchronizationPointResponseMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getLabel() < rhs.getLabel()) return true;
  if (rhs.getLabel() < getLabel()) return false;
  if (getRegisterFederationSynchronizationPointResponseType() < rhs.getRegisterFederationSynchronizationPointResponseType()) return true;
  if (rhs.getRegisterFederationSynchronizationPointResponseType() < getRegisterFederationSynchronizationPointResponseType()) return false;
  return false;
}

AnnounceSynchronizationPointMessage::AnnounceSynchronizationPointMessage() :
  _federationHandle(),
  _label(),
  _tag(),
  _addJoiningFederates(),
  _federateHandleVector()
{
}

AnnounceSynchronizationPointMessage::~AnnounceSynchronizationPointMessage()
{
}

const char*
AnnounceSynchronizationPointMessage::getTypeName() const
{
  return "AnnounceSynchronizationPointMessage";
}

void
AnnounceSynchronizationPointMessage::out(std::ostream& os) const
{
  os << "AnnounceSynchronizationPointMessage " << *this;
}

void
AnnounceSynchronizationPointMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
AnnounceSynchronizationPointMessage::operator==(const AbstractMessage& rhs) const
{
  const AnnounceSynchronizationPointMessage* message = dynamic_cast<const AnnounceSynchronizationPointMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
AnnounceSynchronizationPointMessage::operator==(const AnnounceSynchronizationPointMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getLabel() != rhs.getLabel()) return false;
  if (getTag() != rhs.getTag()) return false;
  if (getAddJoiningFederates() != rhs.getAddJoiningFederates()) return false;
  if (getFederateHandleVector() != rhs.getFederateHandleVector()) return false;
  return true;
}

bool
AnnounceSynchronizationPointMessage::operator<(const AnnounceSynchronizationPointMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getLabel() < rhs.getLabel()) return true;
  if (rhs.getLabel() < getLabel()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  if (getAddJoiningFederates() < rhs.getAddJoiningFederates()) return true;
  if (rhs.getAddJoiningFederates() < getAddJoiningFederates()) return false;
  if (getFederateHandleVector() < rhs.getFederateHandleVector()) return true;
  if (rhs.getFederateHandleVector() < getFederateHandleVector()) return false;
  return false;
}

SynchronizationPointAchievedMessage::SynchronizationPointAchievedMessage() :
  _federationHandle(),
  _label(),
  _federateHandleBoolPairVector()
{
}

SynchronizationPointAchievedMessage::~SynchronizationPointAchievedMessage()
{
}

const char*
SynchronizationPointAchievedMessage::getTypeName() const
{
  return "SynchronizationPointAchievedMessage";
}

void
SynchronizationPointAchievedMessage::out(std::ostream& os) const
{
  os << "SynchronizationPointAchievedMessage " << *this;
}

void
SynchronizationPointAchievedMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
SynchronizationPointAchievedMessage::operator==(const AbstractMessage& rhs) const
{
  const SynchronizationPointAchievedMessage* message = dynamic_cast<const SynchronizationPointAchievedMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
SynchronizationPointAchievedMessage::operator==(const SynchronizationPointAchievedMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getLabel() != rhs.getLabel()) return false;
  if (getFederateHandleBoolPairVector() != rhs.getFederateHandleBoolPairVector()) return false;
  return true;
}

bool
SynchronizationPointAchievedMessage::operator<(const SynchronizationPointAchievedMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getLabel() < rhs.getLabel()) return true;
  if (rhs.getLabel() < getLabel()) return false;
  if (getFederateHandleBoolPairVector() < rhs.getFederateHandleBoolPairVector()) return true;
  if (rhs.getFederateHandleBoolPairVector() < getFederateHandleBoolPairVector()) return false;
  return false;
}

FederationSynchronizedMessage::FederationSynchronizedMessage() :
  _federationHandle(),
  _label(),
  _federateHandleBoolPairVector()
{
}

FederationSynchronizedMessage::~FederationSynchronizedMessage()
{
}

const char*
FederationSynchronizedMessage::getTypeName() const
{
  return "FederationSynchronizedMessage";
}

void
FederationSynchronizedMessage::out(std::ostream& os) const
{
  os << "FederationSynchronizedMessage " << *this;
}

void
FederationSynchronizedMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
FederationSynchronizedMessage::operator==(const AbstractMessage& rhs) const
{
  const FederationSynchronizedMessage* message = dynamic_cast<const FederationSynchronizedMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
FederationSynchronizedMessage::operator==(const FederationSynchronizedMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getLabel() != rhs.getLabel()) return false;
  if (getFederateHandleBoolPairVector() != rhs.getFederateHandleBoolPairVector()) return false;
  return true;
}

bool
FederationSynchronizedMessage::operator<(const FederationSynchronizedMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getLabel() < rhs.getLabel()) return true;
  if (rhs.getLabel() < getLabel()) return false;
  if (getFederateHandleBoolPairVector() < rhs.getFederateHandleBoolPairVector()) return true;
  if (rhs.getFederateHandleBoolPairVector() < getFederateHandleBoolPairVector()) return false;
  return false;
}

EnableTimeRegulationRequestMessage::EnableTimeRegulationRequestMessage() :
  _federationHandle(),
  _federateHandle(),
  _timeStamp(),
  _commitId()
{
}

EnableTimeRegulationRequestMessage::~EnableTimeRegulationRequestMessage()
{
}

const char*
EnableTimeRegulationRequestMessage::getTypeName() const
{
  return "EnableTimeRegulationRequestMessage";
}

void
EnableTimeRegulationRequestMessage::out(std::ostream& os) const
{
  os << "EnableTimeRegulationRequestMessage " << *this;
}

void
EnableTimeRegulationRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
EnableTimeRegulationRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const EnableTimeRegulationRequestMessage* message = dynamic_cast<const EnableTimeRegulationRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
EnableTimeRegulationRequestMessage::operator==(const EnableTimeRegulationRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getTimeStamp() != rhs.getTimeStamp()) return false;
  if (getCommitId() != rhs.getCommitId()) return false;
  return true;
}

bool
EnableTimeRegulationRequestMessage::operator<(const EnableTimeRegulationRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getTimeStamp() < rhs.getTimeStamp()) return true;
  if (rhs.getTimeStamp() < getTimeStamp()) return false;
  if (getCommitId() < rhs.getCommitId()) return true;
  if (rhs.getCommitId() < getCommitId()) return false;
  return false;
}

EnableTimeRegulationResponseMessage::EnableTimeRegulationResponseMessage() :
  _federationHandle(),
  _federateHandle(),
  _respondingFederateHandle(),
  _timeStampValid(),
  _timeStamp()
{
}

EnableTimeRegulationResponseMessage::~EnableTimeRegulationResponseMessage()
{
}

const char*
EnableTimeRegulationResponseMessage::getTypeName() const
{
  return "EnableTimeRegulationResponseMessage";
}

void
EnableTimeRegulationResponseMessage::out(std::ostream& os) const
{
  os << "EnableTimeRegulationResponseMessage " << *this;
}

void
EnableTimeRegulationResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
EnableTimeRegulationResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const EnableTimeRegulationResponseMessage* message = dynamic_cast<const EnableTimeRegulationResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
EnableTimeRegulationResponseMessage::operator==(const EnableTimeRegulationResponseMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getRespondingFederateHandle() != rhs.getRespondingFederateHandle()) return false;
  if (getTimeStampValid() != rhs.getTimeStampValid()) return false;
  if (getTimeStamp() != rhs.getTimeStamp()) return false;
  return true;
}

bool
EnableTimeRegulationResponseMessage::operator<(const EnableTimeRegulationResponseMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getRespondingFederateHandle() < rhs.getRespondingFederateHandle()) return true;
  if (rhs.getRespondingFederateHandle() < getRespondingFederateHandle()) return false;
  if (getTimeStampValid() < rhs.getTimeStampValid()) return true;
  if (rhs.getTimeStampValid() < getTimeStampValid()) return false;
  if (getTimeStamp() < rhs.getTimeStamp()) return true;
  if (rhs.getTimeStamp() < getTimeStamp()) return false;
  return false;
}

DisableTimeRegulationRequestMessage::DisableTimeRegulationRequestMessage() :
  _federationHandle(),
  _federateHandle()
{
}

DisableTimeRegulationRequestMessage::~DisableTimeRegulationRequestMessage()
{
}

const char*
DisableTimeRegulationRequestMessage::getTypeName() const
{
  return "DisableTimeRegulationRequestMessage";
}

void
DisableTimeRegulationRequestMessage::out(std::ostream& os) const
{
  os << "DisableTimeRegulationRequestMessage " << *this;
}

void
DisableTimeRegulationRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
DisableTimeRegulationRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const DisableTimeRegulationRequestMessage* message = dynamic_cast<const DisableTimeRegulationRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
DisableTimeRegulationRequestMessage::operator==(const DisableTimeRegulationRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  return true;
}

bool
DisableTimeRegulationRequestMessage::operator<(const DisableTimeRegulationRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  return false;
}

CommitLowerBoundTimeStampMessage::CommitLowerBoundTimeStampMessage() :
  _federationHandle(),
  _federateHandle(),
  _timeStamp(),
  _commitType(),
  _commitId()
{
}

CommitLowerBoundTimeStampMessage::~CommitLowerBoundTimeStampMessage()
{
}

const char*
CommitLowerBoundTimeStampMessage::getTypeName() const
{
  return "CommitLowerBoundTimeStampMessage";
}

void
CommitLowerBoundTimeStampMessage::out(std::ostream& os) const
{
  os << "CommitLowerBoundTimeStampMessage " << *this;
}

void
CommitLowerBoundTimeStampMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
CommitLowerBoundTimeStampMessage::operator==(const AbstractMessage& rhs) const
{
  const CommitLowerBoundTimeStampMessage* message = dynamic_cast<const CommitLowerBoundTimeStampMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
CommitLowerBoundTimeStampMessage::operator==(const CommitLowerBoundTimeStampMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getTimeStamp() != rhs.getTimeStamp()) return false;
  if (getCommitType() != rhs.getCommitType()) return false;
  if (getCommitId() != rhs.getCommitId()) return false;
  return true;
}

bool
CommitLowerBoundTimeStampMessage::operator<(const CommitLowerBoundTimeStampMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getTimeStamp() < rhs.getTimeStamp()) return true;
  if (rhs.getTimeStamp() < getTimeStamp()) return false;
  if (getCommitType() < rhs.getCommitType()) return true;
  if (rhs.getCommitType() < getCommitType()) return false;
  if (getCommitId() < rhs.getCommitId()) return true;
  if (rhs.getCommitId() < getCommitId()) return false;
  return false;
}

CommitLowerBoundTimeStampResponseMessage::CommitLowerBoundTimeStampResponseMessage() :
  _federationHandle(),
  _federateHandle(),
  _sendingFederateHandle(),
  _commitId()
{
}

CommitLowerBoundTimeStampResponseMessage::~CommitLowerBoundTimeStampResponseMessage()
{
}

const char*
CommitLowerBoundTimeStampResponseMessage::getTypeName() const
{
  return "CommitLowerBoundTimeStampResponseMessage";
}

void
CommitLowerBoundTimeStampResponseMessage::out(std::ostream& os) const
{
  os << "CommitLowerBoundTimeStampResponseMessage " << *this;
}

void
CommitLowerBoundTimeStampResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
CommitLowerBoundTimeStampResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const CommitLowerBoundTimeStampResponseMessage* message = dynamic_cast<const CommitLowerBoundTimeStampResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
CommitLowerBoundTimeStampResponseMessage::operator==(const CommitLowerBoundTimeStampResponseMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getSendingFederateHandle() != rhs.getSendingFederateHandle()) return false;
  if (getCommitId() != rhs.getCommitId()) return false;
  return true;
}

bool
CommitLowerBoundTimeStampResponseMessage::operator<(const CommitLowerBoundTimeStampResponseMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getSendingFederateHandle() < rhs.getSendingFederateHandle()) return true;
  if (rhs.getSendingFederateHandle() < getSendingFederateHandle()) return false;
  if (getCommitId() < rhs.getCommitId()) return true;
  if (rhs.getCommitId() < getCommitId()) return false;
  return false;
}

LockedByNextMessageRequestMessage::LockedByNextMessageRequestMessage() :
  _federationHandle(),
  _sendingFederateHandle(),
  _lockedByNextMessage()
{
}

LockedByNextMessageRequestMessage::~LockedByNextMessageRequestMessage()
{
}

const char*
LockedByNextMessageRequestMessage::getTypeName() const
{
  return "LockedByNextMessageRequestMessage";
}

void
LockedByNextMessageRequestMessage::out(std::ostream& os) const
{
  os << "LockedByNextMessageRequestMessage " << *this;
}

void
LockedByNextMessageRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
LockedByNextMessageRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const LockedByNextMessageRequestMessage* message = dynamic_cast<const LockedByNextMessageRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
LockedByNextMessageRequestMessage::operator==(const LockedByNextMessageRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getSendingFederateHandle() != rhs.getSendingFederateHandle()) return false;
  if (getLockedByNextMessage() != rhs.getLockedByNextMessage()) return false;
  return true;
}

bool
LockedByNextMessageRequestMessage::operator<(const LockedByNextMessageRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getSendingFederateHandle() < rhs.getSendingFederateHandle()) return true;
  if (rhs.getSendingFederateHandle() < getSendingFederateHandle()) return false;
  if (getLockedByNextMessage() < rhs.getLockedByNextMessage()) return true;
  if (rhs.getLockedByNextMessage() < getLockedByNextMessage()) return false;
  return false;
}

TimeConstrainedEnabledMessage::TimeConstrainedEnabledMessage()
{
}

TimeConstrainedEnabledMessage::~TimeConstrainedEnabledMessage()
{
}

const char*
TimeConstrainedEnabledMessage::getTypeName() const
{
  return "TimeConstrainedEnabledMessage";
}

void
TimeConstrainedEnabledMessage::out(std::ostream& os) const
{
  os << "TimeConstrainedEnabledMessage " << *this;
}

void
TimeConstrainedEnabledMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TimeConstrainedEnabledMessage::operator==(const AbstractMessage& rhs) const
{
  const TimeConstrainedEnabledMessage* message = dynamic_cast<const TimeConstrainedEnabledMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TimeConstrainedEnabledMessage::operator==(const TimeConstrainedEnabledMessage& rhs) const
{
  return true;
}

bool
TimeConstrainedEnabledMessage::operator<(const TimeConstrainedEnabledMessage& rhs) const
{
  return false;
}

TimeRegulationEnabledMessage::TimeRegulationEnabledMessage()
{
}

TimeRegulationEnabledMessage::~TimeRegulationEnabledMessage()
{
}

const char*
TimeRegulationEnabledMessage::getTypeName() const
{
  return "TimeRegulationEnabledMessage";
}

void
TimeRegulationEnabledMessage::out(std::ostream& os) const
{
  os << "TimeRegulationEnabledMessage " << *this;
}

void
TimeRegulationEnabledMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TimeRegulationEnabledMessage::operator==(const AbstractMessage& rhs) const
{
  const TimeRegulationEnabledMessage* message = dynamic_cast<const TimeRegulationEnabledMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TimeRegulationEnabledMessage::operator==(const TimeRegulationEnabledMessage& rhs) const
{
  return true;
}

bool
TimeRegulationEnabledMessage::operator<(const TimeRegulationEnabledMessage& rhs) const
{
  return false;
}

TimeAdvanceGrantedMessage::TimeAdvanceGrantedMessage()
{
}

TimeAdvanceGrantedMessage::~TimeAdvanceGrantedMessage()
{
}

const char*
TimeAdvanceGrantedMessage::getTypeName() const
{
  return "TimeAdvanceGrantedMessage";
}

void
TimeAdvanceGrantedMessage::out(std::ostream& os) const
{
  os << "TimeAdvanceGrantedMessage " << *this;
}

void
TimeAdvanceGrantedMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TimeAdvanceGrantedMessage::operator==(const AbstractMessage& rhs) const
{
  const TimeAdvanceGrantedMessage* message = dynamic_cast<const TimeAdvanceGrantedMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TimeAdvanceGrantedMessage::operator==(const TimeAdvanceGrantedMessage& rhs) const
{
  return true;
}

bool
TimeAdvanceGrantedMessage::operator<(const TimeAdvanceGrantedMessage& rhs) const
{
  return false;
}

InsertRegionMessage::InsertRegionMessage() :
  _federationHandle(),
  _regionHandleDimensionHandleSetPairVector()
{
}

InsertRegionMessage::~InsertRegionMessage()
{
}

const char*
InsertRegionMessage::getTypeName() const
{
  return "InsertRegionMessage";
}

void
InsertRegionMessage::out(std::ostream& os) const
{
  os << "InsertRegionMessage " << *this;
}

void
InsertRegionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
InsertRegionMessage::operator==(const AbstractMessage& rhs) const
{
  const InsertRegionMessage* message = dynamic_cast<const InsertRegionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
InsertRegionMessage::operator==(const InsertRegionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getRegionHandleDimensionHandleSetPairVector() != rhs.getRegionHandleDimensionHandleSetPairVector()) return false;
  return true;
}

bool
InsertRegionMessage::operator<(const InsertRegionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getRegionHandleDimensionHandleSetPairVector() < rhs.getRegionHandleDimensionHandleSetPairVector()) return true;
  if (rhs.getRegionHandleDimensionHandleSetPairVector() < getRegionHandleDimensionHandleSetPairVector()) return false;
  return false;
}

CommitRegionMessage::CommitRegionMessage() :
  _federationHandle(),
  _regionHandleRegionValuePairVector()
{
}

CommitRegionMessage::~CommitRegionMessage()
{
}

const char*
CommitRegionMessage::getTypeName() const
{
  return "CommitRegionMessage";
}

void
CommitRegionMessage::out(std::ostream& os) const
{
  os << "CommitRegionMessage " << *this;
}

void
CommitRegionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
CommitRegionMessage::operator==(const AbstractMessage& rhs) const
{
  const CommitRegionMessage* message = dynamic_cast<const CommitRegionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
CommitRegionMessage::operator==(const CommitRegionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getRegionHandleRegionValuePairVector() != rhs.getRegionHandleRegionValuePairVector()) return false;
  return true;
}

bool
CommitRegionMessage::operator<(const CommitRegionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getRegionHandleRegionValuePairVector() < rhs.getRegionHandleRegionValuePairVector()) return true;
  if (rhs.getRegionHandleRegionValuePairVector() < getRegionHandleRegionValuePairVector()) return false;
  return false;
}

EraseRegionMessage::EraseRegionMessage() :
  _federationHandle(),
  _regionHandleVector()
{
}

EraseRegionMessage::~EraseRegionMessage()
{
}

const char*
EraseRegionMessage::getTypeName() const
{
  return "EraseRegionMessage";
}

void
EraseRegionMessage::out(std::ostream& os) const
{
  os << "EraseRegionMessage " << *this;
}

void
EraseRegionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
EraseRegionMessage::operator==(const AbstractMessage& rhs) const
{
  const EraseRegionMessage* message = dynamic_cast<const EraseRegionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
EraseRegionMessage::operator==(const EraseRegionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getRegionHandleVector() != rhs.getRegionHandleVector()) return false;
  return true;
}

bool
EraseRegionMessage::operator<(const EraseRegionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getRegionHandleVector() < rhs.getRegionHandleVector()) return true;
  if (rhs.getRegionHandleVector() < getRegionHandleVector()) return false;
  return false;
}

ChangeInteractionClassPublicationMessage::ChangeInteractionClassPublicationMessage() :
  _federationHandle(),
  _publicationType(),
  _interactionClassHandle()
{
}

ChangeInteractionClassPublicationMessage::~ChangeInteractionClassPublicationMessage()
{
}

const char*
ChangeInteractionClassPublicationMessage::getTypeName() const
{
  return "ChangeInteractionClassPublicationMessage";
}

void
ChangeInteractionClassPublicationMessage::out(std::ostream& os) const
{
  os << "ChangeInteractionClassPublicationMessage " << *this;
}

void
ChangeInteractionClassPublicationMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ChangeInteractionClassPublicationMessage::operator==(const AbstractMessage& rhs) const
{
  const ChangeInteractionClassPublicationMessage* message = dynamic_cast<const ChangeInteractionClassPublicationMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ChangeInteractionClassPublicationMessage::operator==(const ChangeInteractionClassPublicationMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getPublicationType() != rhs.getPublicationType()) return false;
  if (getInteractionClassHandle() != rhs.getInteractionClassHandle()) return false;
  return true;
}

bool
ChangeInteractionClassPublicationMessage::operator<(const ChangeInteractionClassPublicationMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getPublicationType() < rhs.getPublicationType()) return true;
  if (rhs.getPublicationType() < getPublicationType()) return false;
  if (getInteractionClassHandle() < rhs.getInteractionClassHandle()) return true;
  if (rhs.getInteractionClassHandle() < getInteractionClassHandle()) return false;
  return false;
}

ChangeObjectClassPublicationMessage::ChangeObjectClassPublicationMessage() :
  _federationHandle(),
  _publicationType(),
  _objectClassHandle(),
  _attributeHandles()
{
}

ChangeObjectClassPublicationMessage::~ChangeObjectClassPublicationMessage()
{
}

const char*
ChangeObjectClassPublicationMessage::getTypeName() const
{
  return "ChangeObjectClassPublicationMessage";
}

void
ChangeObjectClassPublicationMessage::out(std::ostream& os) const
{
  os << "ChangeObjectClassPublicationMessage " << *this;
}

void
ChangeObjectClassPublicationMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ChangeObjectClassPublicationMessage::operator==(const AbstractMessage& rhs) const
{
  const ChangeObjectClassPublicationMessage* message = dynamic_cast<const ChangeObjectClassPublicationMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ChangeObjectClassPublicationMessage::operator==(const ChangeObjectClassPublicationMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getPublicationType() != rhs.getPublicationType()) return false;
  if (getObjectClassHandle() != rhs.getObjectClassHandle()) return false;
  if (getAttributeHandles() != rhs.getAttributeHandles()) return false;
  return true;
}

bool
ChangeObjectClassPublicationMessage::operator<(const ChangeObjectClassPublicationMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getPublicationType() < rhs.getPublicationType()) return true;
  if (rhs.getPublicationType() < getPublicationType()) return false;
  if (getObjectClassHandle() < rhs.getObjectClassHandle()) return true;
  if (rhs.getObjectClassHandle() < getObjectClassHandle()) return false;
  if (getAttributeHandles() < rhs.getAttributeHandles()) return true;
  if (rhs.getAttributeHandles() < getAttributeHandles()) return false;
  return false;
}

ChangeInteractionClassSubscriptionMessage::ChangeInteractionClassSubscriptionMessage() :
  _federationHandle(),
  _subscriptionType(),
  _interactionClassHandle()
{
}

ChangeInteractionClassSubscriptionMessage::~ChangeInteractionClassSubscriptionMessage()
{
}

const char*
ChangeInteractionClassSubscriptionMessage::getTypeName() const
{
  return "ChangeInteractionClassSubscriptionMessage";
}

void
ChangeInteractionClassSubscriptionMessage::out(std::ostream& os) const
{
  os << "ChangeInteractionClassSubscriptionMessage " << *this;
}

void
ChangeInteractionClassSubscriptionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ChangeInteractionClassSubscriptionMessage::operator==(const AbstractMessage& rhs) const
{
  const ChangeInteractionClassSubscriptionMessage* message = dynamic_cast<const ChangeInteractionClassSubscriptionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ChangeInteractionClassSubscriptionMessage::operator==(const ChangeInteractionClassSubscriptionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getSubscriptionType() != rhs.getSubscriptionType()) return false;
  if (getInteractionClassHandle() != rhs.getInteractionClassHandle()) return false;
  return true;
}

bool
ChangeInteractionClassSubscriptionMessage::operator<(const ChangeInteractionClassSubscriptionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getSubscriptionType() < rhs.getSubscriptionType()) return true;
  if (rhs.getSubscriptionType() < getSubscriptionType()) return false;
  if (getInteractionClassHandle() < rhs.getInteractionClassHandle()) return true;
  if (rhs.getInteractionClassHandle() < getInteractionClassHandle()) return false;
  return false;
}

ChangeObjectClassSubscriptionMessage::ChangeObjectClassSubscriptionMessage() :
  _federationHandle(),
  _subscriptionType(),
  _objectClassHandle(),
  _attributeHandles()
{
}

ChangeObjectClassSubscriptionMessage::~ChangeObjectClassSubscriptionMessage()
{
}

const char*
ChangeObjectClassSubscriptionMessage::getTypeName() const
{
  return "ChangeObjectClassSubscriptionMessage";
}

void
ChangeObjectClassSubscriptionMessage::out(std::ostream& os) const
{
  os << "ChangeObjectClassSubscriptionMessage " << *this;
}

void
ChangeObjectClassSubscriptionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ChangeObjectClassSubscriptionMessage::operator==(const AbstractMessage& rhs) const
{
  const ChangeObjectClassSubscriptionMessage* message = dynamic_cast<const ChangeObjectClassSubscriptionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ChangeObjectClassSubscriptionMessage::operator==(const ChangeObjectClassSubscriptionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getSubscriptionType() != rhs.getSubscriptionType()) return false;
  if (getObjectClassHandle() != rhs.getObjectClassHandle()) return false;
  if (getAttributeHandles() != rhs.getAttributeHandles()) return false;
  return true;
}

bool
ChangeObjectClassSubscriptionMessage::operator<(const ChangeObjectClassSubscriptionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getSubscriptionType() < rhs.getSubscriptionType()) return true;
  if (rhs.getSubscriptionType() < getSubscriptionType()) return false;
  if (getObjectClassHandle() < rhs.getObjectClassHandle()) return true;
  if (rhs.getObjectClassHandle() < getObjectClassHandle()) return false;
  if (getAttributeHandles() < rhs.getAttributeHandles()) return true;
  if (rhs.getAttributeHandles() < getAttributeHandles()) return false;
  return false;
}

RegistrationForObjectClassMessage::RegistrationForObjectClassMessage() :
  _objectClassHandle(),
  _start()
{
}

RegistrationForObjectClassMessage::~RegistrationForObjectClassMessage()
{
}

const char*
RegistrationForObjectClassMessage::getTypeName() const
{
  return "RegistrationForObjectClassMessage";
}

void
RegistrationForObjectClassMessage::out(std::ostream& os) const
{
  os << "RegistrationForObjectClassMessage " << *this;
}

void
RegistrationForObjectClassMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
RegistrationForObjectClassMessage::operator==(const AbstractMessage& rhs) const
{
  const RegistrationForObjectClassMessage* message = dynamic_cast<const RegistrationForObjectClassMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
RegistrationForObjectClassMessage::operator==(const RegistrationForObjectClassMessage& rhs) const
{
  if (getObjectClassHandle() != rhs.getObjectClassHandle()) return false;
  if (getStart() != rhs.getStart()) return false;
  return true;
}

bool
RegistrationForObjectClassMessage::operator<(const RegistrationForObjectClassMessage& rhs) const
{
  if (getObjectClassHandle() < rhs.getObjectClassHandle()) return true;
  if (rhs.getObjectClassHandle() < getObjectClassHandle()) return false;
  if (getStart() < rhs.getStart()) return true;
  if (rhs.getStart() < getStart()) return false;
  return false;
}

AttributesInScopeMessage::AttributesInScopeMessage() :
  _objectInstanceHandle(),
  _attributeHandles(),
  _inScope()
{
}

AttributesInScopeMessage::~AttributesInScopeMessage()
{
}

const char*
AttributesInScopeMessage::getTypeName() const
{
  return "AttributesInScopeMessage";
}

void
AttributesInScopeMessage::out(std::ostream& os) const
{
  os << "AttributesInScopeMessage " << *this;
}

void
AttributesInScopeMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
AttributesInScopeMessage::operator==(const AbstractMessage& rhs) const
{
  const AttributesInScopeMessage* message = dynamic_cast<const AttributesInScopeMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
AttributesInScopeMessage::operator==(const AttributesInScopeMessage& rhs) const
{
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getAttributeHandles() != rhs.getAttributeHandles()) return false;
  if (getInScope() != rhs.getInScope()) return false;
  return true;
}

bool
AttributesInScopeMessage::operator<(const AttributesInScopeMessage& rhs) const
{
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getAttributeHandles() < rhs.getAttributeHandles()) return true;
  if (rhs.getAttributeHandles() < getAttributeHandles()) return false;
  if (getInScope() < rhs.getInScope()) return true;
  if (rhs.getInScope() < getInScope()) return false;
  return false;
}

ObjectInstanceHandle
AttributesInScopeMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

TurnUpdatesOnForInstanceMessage::TurnUpdatesOnForInstanceMessage() :
  _objectInstanceHandle(),
  _attributeHandles(),
  _updateRate(),
  _on()
{
}

TurnUpdatesOnForInstanceMessage::~TurnUpdatesOnForInstanceMessage()
{
}

const char*
TurnUpdatesOnForInstanceMessage::getTypeName() const
{
  return "TurnUpdatesOnForInstanceMessage";
}

void
TurnUpdatesOnForInstanceMessage::out(std::ostream& os) const
{
  os << "TurnUpdatesOnForInstanceMessage " << *this;
}

void
TurnUpdatesOnForInstanceMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TurnUpdatesOnForInstanceMessage::operator==(const AbstractMessage& rhs) const
{
  const TurnUpdatesOnForInstanceMessage* message = dynamic_cast<const TurnUpdatesOnForInstanceMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TurnUpdatesOnForInstanceMessage::operator==(const TurnUpdatesOnForInstanceMessage& rhs) const
{
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getAttributeHandles() != rhs.getAttributeHandles()) return false;
  if (getUpdateRate() != rhs.getUpdateRate()) return false;
  if (getOn() != rhs.getOn()) return false;
  return true;
}

bool
TurnUpdatesOnForInstanceMessage::operator<(const TurnUpdatesOnForInstanceMessage& rhs) const
{
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getAttributeHandles() < rhs.getAttributeHandles()) return true;
  if (rhs.getAttributeHandles() < getAttributeHandles()) return false;
  if (getUpdateRate() < rhs.getUpdateRate()) return true;
  if (rhs.getUpdateRate() < getUpdateRate()) return false;
  if (getOn() < rhs.getOn()) return true;
  if (rhs.getOn() < getOn()) return false;
  return false;
}

ObjectInstanceHandle
TurnUpdatesOnForInstanceMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

TurnInteractionsOnMessage::TurnInteractionsOnMessage() :
  _interactionClassHandle(),
  _on()
{
}

TurnInteractionsOnMessage::~TurnInteractionsOnMessage()
{
}

const char*
TurnInteractionsOnMessage::getTypeName() const
{
  return "TurnInteractionsOnMessage";
}

void
TurnInteractionsOnMessage::out(std::ostream& os) const
{
  os << "TurnInteractionsOnMessage " << *this;
}

void
TurnInteractionsOnMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TurnInteractionsOnMessage::operator==(const AbstractMessage& rhs) const
{
  const TurnInteractionsOnMessage* message = dynamic_cast<const TurnInteractionsOnMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TurnInteractionsOnMessage::operator==(const TurnInteractionsOnMessage& rhs) const
{
  if (getInteractionClassHandle() != rhs.getInteractionClassHandle()) return false;
  if (getOn() != rhs.getOn()) return false;
  return true;
}

bool
TurnInteractionsOnMessage::operator<(const TurnInteractionsOnMessage& rhs) const
{
  if (getInteractionClassHandle() < rhs.getInteractionClassHandle()) return true;
  if (rhs.getInteractionClassHandle() < getInteractionClassHandle()) return false;
  if (getOn() < rhs.getOn()) return true;
  if (rhs.getOn() < getOn()) return false;
  return false;
}

InteractionMessage::InteractionMessage() :
  _federationHandle(),
  _federateHandle(),
  _interactionClassHandle(),
  _transportationType(),
  _tag(),
  _parameterValues()
{
}

InteractionMessage::~InteractionMessage()
{
}

const char*
InteractionMessage::getTypeName() const
{
  return "InteractionMessage";
}

void
InteractionMessage::out(std::ostream& os) const
{
  os << "InteractionMessage " << *this;
}

void
InteractionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
InteractionMessage::operator==(const AbstractMessage& rhs) const
{
  const InteractionMessage* message = dynamic_cast<const InteractionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
InteractionMessage::operator==(const InteractionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getInteractionClassHandle() != rhs.getInteractionClassHandle()) return false;
  if (getTransportationType() != rhs.getTransportationType()) return false;
  if (getTag() != rhs.getTag()) return false;
  if (getParameterValues() != rhs.getParameterValues()) return false;
  return true;
}

bool
InteractionMessage::operator<(const InteractionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getInteractionClassHandle() < rhs.getInteractionClassHandle()) return true;
  if (rhs.getInteractionClassHandle() < getInteractionClassHandle()) return false;
  if (getTransportationType() < rhs.getTransportationType()) return true;
  if (rhs.getTransportationType() < getTransportationType()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  if (getParameterValues() < rhs.getParameterValues()) return true;
  if (rhs.getParameterValues() < getParameterValues()) return false;
  return false;
}

bool
InteractionMessage::getReliable() const
{
  return getTransportationType() == RELIABLE;
}

TimeStampedInteractionMessage::TimeStampedInteractionMessage() :
  _federationHandle(),
  _federateHandle(),
  _interactionClassHandle(),
  _orderType(),
  _transportationType(),
  _tag(),
  _timeStamp(),
  _messageRetractionHandle(),
  _parameterValues()
{
}

TimeStampedInteractionMessage::~TimeStampedInteractionMessage()
{
}

const char*
TimeStampedInteractionMessage::getTypeName() const
{
  return "TimeStampedInteractionMessage";
}

void
TimeStampedInteractionMessage::out(std::ostream& os) const
{
  os << "TimeStampedInteractionMessage " << *this;
}

void
TimeStampedInteractionMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TimeStampedInteractionMessage::operator==(const AbstractMessage& rhs) const
{
  const TimeStampedInteractionMessage* message = dynamic_cast<const TimeStampedInteractionMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TimeStampedInteractionMessage::operator==(const TimeStampedInteractionMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getInteractionClassHandle() != rhs.getInteractionClassHandle()) return false;
  if (getOrderType() != rhs.getOrderType()) return false;
  if (getTransportationType() != rhs.getTransportationType()) return false;
  if (getTag() != rhs.getTag()) return false;
  if (getTimeStamp() != rhs.getTimeStamp()) return false;
  if (getMessageRetractionHandle() != rhs.getMessageRetractionHandle()) return false;
  if (getParameterValues() != rhs.getParameterValues()) return false;
  return true;
}

bool
TimeStampedInteractionMessage::operator<(const TimeStampedInteractionMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getInteractionClassHandle() < rhs.getInteractionClassHandle()) return true;
  if (rhs.getInteractionClassHandle() < getInteractionClassHandle()) return false;
  if (getOrderType() < rhs.getOrderType()) return true;
  if (rhs.getOrderType() < getOrderType()) return false;
  if (getTransportationType() < rhs.getTransportationType()) return true;
  if (rhs.getTransportationType() < getTransportationType()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  if (getTimeStamp() < rhs.getTimeStamp()) return true;
  if (rhs.getTimeStamp() < getTimeStamp()) return false;
  if (getMessageRetractionHandle() < rhs.getMessageRetractionHandle()) return true;
  if (rhs.getMessageRetractionHandle() < getMessageRetractionHandle()) return false;
  if (getParameterValues() < rhs.getParameterValues()) return true;
  if (rhs.getParameterValues() < getParameterValues()) return false;
  return false;
}

bool
TimeStampedInteractionMessage::getReliable() const
{
  return getTransportationType() == RELIABLE;
}

ObjectInstanceHandlesRequestMessage::ObjectInstanceHandlesRequestMessage() :
  _federationHandle(),
  _federateHandle(),
  _count()
{
}

ObjectInstanceHandlesRequestMessage::~ObjectInstanceHandlesRequestMessage()
{
}

const char*
ObjectInstanceHandlesRequestMessage::getTypeName() const
{
  return "ObjectInstanceHandlesRequestMessage";
}

void
ObjectInstanceHandlesRequestMessage::out(std::ostream& os) const
{
  os << "ObjectInstanceHandlesRequestMessage " << *this;
}

void
ObjectInstanceHandlesRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ObjectInstanceHandlesRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const ObjectInstanceHandlesRequestMessage* message = dynamic_cast<const ObjectInstanceHandlesRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ObjectInstanceHandlesRequestMessage::operator==(const ObjectInstanceHandlesRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getCount() != rhs.getCount()) return false;
  return true;
}

bool
ObjectInstanceHandlesRequestMessage::operator<(const ObjectInstanceHandlesRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getCount() < rhs.getCount()) return true;
  if (rhs.getCount() < getCount()) return false;
  return false;
}

ObjectInstanceHandlesResponseMessage::ObjectInstanceHandlesResponseMessage() :
  _federationHandle(),
  _federateHandle(),
  _objectInstanceHandleNamePairVector()
{
}

ObjectInstanceHandlesResponseMessage::~ObjectInstanceHandlesResponseMessage()
{
}

const char*
ObjectInstanceHandlesResponseMessage::getTypeName() const
{
  return "ObjectInstanceHandlesResponseMessage";
}

void
ObjectInstanceHandlesResponseMessage::out(std::ostream& os) const
{
  os << "ObjectInstanceHandlesResponseMessage " << *this;
}

void
ObjectInstanceHandlesResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ObjectInstanceHandlesResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const ObjectInstanceHandlesResponseMessage* message = dynamic_cast<const ObjectInstanceHandlesResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ObjectInstanceHandlesResponseMessage::operator==(const ObjectInstanceHandlesResponseMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getObjectInstanceHandleNamePairVector() != rhs.getObjectInstanceHandleNamePairVector()) return false;
  return true;
}

bool
ObjectInstanceHandlesResponseMessage::operator<(const ObjectInstanceHandlesResponseMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getObjectInstanceHandleNamePairVector() < rhs.getObjectInstanceHandleNamePairVector()) return true;
  if (rhs.getObjectInstanceHandleNamePairVector() < getObjectInstanceHandleNamePairVector()) return false;
  return false;
}

ReleaseMultipleObjectInstanceNameHandlePairsMessage::ReleaseMultipleObjectInstanceNameHandlePairsMessage() :
  _federationHandle(),
  _objectInstanceHandleVector()
{
}

ReleaseMultipleObjectInstanceNameHandlePairsMessage::~ReleaseMultipleObjectInstanceNameHandlePairsMessage()
{
}

const char*
ReleaseMultipleObjectInstanceNameHandlePairsMessage::getTypeName() const
{
  return "ReleaseMultipleObjectInstanceNameHandlePairsMessage";
}

void
ReleaseMultipleObjectInstanceNameHandlePairsMessage::out(std::ostream& os) const
{
  os << "ReleaseMultipleObjectInstanceNameHandlePairsMessage " << *this;
}

void
ReleaseMultipleObjectInstanceNameHandlePairsMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ReleaseMultipleObjectInstanceNameHandlePairsMessage::operator==(const AbstractMessage& rhs) const
{
  const ReleaseMultipleObjectInstanceNameHandlePairsMessage* message = dynamic_cast<const ReleaseMultipleObjectInstanceNameHandlePairsMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ReleaseMultipleObjectInstanceNameHandlePairsMessage::operator==(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getObjectInstanceHandleVector() != rhs.getObjectInstanceHandleVector()) return false;
  return true;
}

bool
ReleaseMultipleObjectInstanceNameHandlePairsMessage::operator<(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getObjectInstanceHandleVector() < rhs.getObjectInstanceHandleVector()) return true;
  if (rhs.getObjectInstanceHandleVector() < getObjectInstanceHandleVector()) return false;
  return false;
}

ReserveObjectInstanceNameRequestMessage::ReserveObjectInstanceNameRequestMessage() :
  _federationHandle(),
  _federateHandle(),
  _name()
{
}

ReserveObjectInstanceNameRequestMessage::~ReserveObjectInstanceNameRequestMessage()
{
}

const char*
ReserveObjectInstanceNameRequestMessage::getTypeName() const
{
  return "ReserveObjectInstanceNameRequestMessage";
}

void
ReserveObjectInstanceNameRequestMessage::out(std::ostream& os) const
{
  os << "ReserveObjectInstanceNameRequestMessage " << *this;
}

void
ReserveObjectInstanceNameRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ReserveObjectInstanceNameRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const ReserveObjectInstanceNameRequestMessage* message = dynamic_cast<const ReserveObjectInstanceNameRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ReserveObjectInstanceNameRequestMessage::operator==(const ReserveObjectInstanceNameRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getName() != rhs.getName()) return false;
  return true;
}

bool
ReserveObjectInstanceNameRequestMessage::operator<(const ReserveObjectInstanceNameRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getName() < rhs.getName()) return true;
  if (rhs.getName() < getName()) return false;
  return false;
}

ReserveObjectInstanceNameResponseMessage::ReserveObjectInstanceNameResponseMessage() :
  _federationHandle(),
  _federateHandle(),
  _objectInstanceHandleNamePair(),
  _success()
{
}

ReserveObjectInstanceNameResponseMessage::~ReserveObjectInstanceNameResponseMessage()
{
}

const char*
ReserveObjectInstanceNameResponseMessage::getTypeName() const
{
  return "ReserveObjectInstanceNameResponseMessage";
}

void
ReserveObjectInstanceNameResponseMessage::out(std::ostream& os) const
{
  os << "ReserveObjectInstanceNameResponseMessage " << *this;
}

void
ReserveObjectInstanceNameResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ReserveObjectInstanceNameResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const ReserveObjectInstanceNameResponseMessage* message = dynamic_cast<const ReserveObjectInstanceNameResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ReserveObjectInstanceNameResponseMessage::operator==(const ReserveObjectInstanceNameResponseMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getObjectInstanceHandleNamePair() != rhs.getObjectInstanceHandleNamePair()) return false;
  if (getSuccess() != rhs.getSuccess()) return false;
  return true;
}

bool
ReserveObjectInstanceNameResponseMessage::operator<(const ReserveObjectInstanceNameResponseMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getObjectInstanceHandleNamePair() < rhs.getObjectInstanceHandleNamePair()) return true;
  if (rhs.getObjectInstanceHandleNamePair() < getObjectInstanceHandleNamePair()) return false;
  if (getSuccess() < rhs.getSuccess()) return true;
  if (rhs.getSuccess() < getSuccess()) return false;
  return false;
}

ReserveMultipleObjectInstanceNameRequestMessage::ReserveMultipleObjectInstanceNameRequestMessage() :
  _federationHandle(),
  _federateHandle(),
  _nameList()
{
}

ReserveMultipleObjectInstanceNameRequestMessage::~ReserveMultipleObjectInstanceNameRequestMessage()
{
}

const char*
ReserveMultipleObjectInstanceNameRequestMessage::getTypeName() const
{
  return "ReserveMultipleObjectInstanceNameRequestMessage";
}

void
ReserveMultipleObjectInstanceNameRequestMessage::out(std::ostream& os) const
{
  os << "ReserveMultipleObjectInstanceNameRequestMessage " << *this;
}

void
ReserveMultipleObjectInstanceNameRequestMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ReserveMultipleObjectInstanceNameRequestMessage::operator==(const AbstractMessage& rhs) const
{
  const ReserveMultipleObjectInstanceNameRequestMessage* message = dynamic_cast<const ReserveMultipleObjectInstanceNameRequestMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ReserveMultipleObjectInstanceNameRequestMessage::operator==(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getNameList() != rhs.getNameList()) return false;
  return true;
}

bool
ReserveMultipleObjectInstanceNameRequestMessage::operator<(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getNameList() < rhs.getNameList()) return true;
  if (rhs.getNameList() < getNameList()) return false;
  return false;
}

ReserveMultipleObjectInstanceNameResponseMessage::ReserveMultipleObjectInstanceNameResponseMessage() :
  _federationHandle(),
  _federateHandle(),
  _objectInstanceHandleNamePairVector(),
  _success()
{
}

ReserveMultipleObjectInstanceNameResponseMessage::~ReserveMultipleObjectInstanceNameResponseMessage()
{
}

const char*
ReserveMultipleObjectInstanceNameResponseMessage::getTypeName() const
{
  return "ReserveMultipleObjectInstanceNameResponseMessage";
}

void
ReserveMultipleObjectInstanceNameResponseMessage::out(std::ostream& os) const
{
  os << "ReserveMultipleObjectInstanceNameResponseMessage " << *this;
}

void
ReserveMultipleObjectInstanceNameResponseMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
ReserveMultipleObjectInstanceNameResponseMessage::operator==(const AbstractMessage& rhs) const
{
  const ReserveMultipleObjectInstanceNameResponseMessage* message = dynamic_cast<const ReserveMultipleObjectInstanceNameResponseMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
ReserveMultipleObjectInstanceNameResponseMessage::operator==(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getObjectInstanceHandleNamePairVector() != rhs.getObjectInstanceHandleNamePairVector()) return false;
  if (getSuccess() != rhs.getSuccess()) return false;
  return true;
}

bool
ReserveMultipleObjectInstanceNameResponseMessage::operator<(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getObjectInstanceHandleNamePairVector() < rhs.getObjectInstanceHandleNamePairVector()) return true;
  if (rhs.getObjectInstanceHandleNamePairVector() < getObjectInstanceHandleNamePairVector()) return false;
  if (getSuccess() < rhs.getSuccess()) return true;
  if (rhs.getSuccess() < getSuccess()) return false;
  return false;
}

InsertObjectInstanceMessage::InsertObjectInstanceMessage() :
  _federationHandle(),
  _objectClassHandle(),
  _objectInstanceHandle(),
  _name(),
  _attributeStateVector()
{
}

InsertObjectInstanceMessage::~InsertObjectInstanceMessage()
{
}

const char*
InsertObjectInstanceMessage::getTypeName() const
{
  return "InsertObjectInstanceMessage";
}

void
InsertObjectInstanceMessage::out(std::ostream& os) const
{
  os << "InsertObjectInstanceMessage " << *this;
}

void
InsertObjectInstanceMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
InsertObjectInstanceMessage::operator==(const AbstractMessage& rhs) const
{
  const InsertObjectInstanceMessage* message = dynamic_cast<const InsertObjectInstanceMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
InsertObjectInstanceMessage::operator==(const InsertObjectInstanceMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getObjectClassHandle() != rhs.getObjectClassHandle()) return false;
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getName() != rhs.getName()) return false;
  if (getAttributeStateVector() != rhs.getAttributeStateVector()) return false;
  return true;
}

bool
InsertObjectInstanceMessage::operator<(const InsertObjectInstanceMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getObjectClassHandle() < rhs.getObjectClassHandle()) return true;
  if (rhs.getObjectClassHandle() < getObjectClassHandle()) return false;
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getName() < rhs.getName()) return true;
  if (rhs.getName() < getName()) return false;
  if (getAttributeStateVector() < rhs.getAttributeStateVector()) return true;
  if (rhs.getAttributeStateVector() < getAttributeStateVector()) return false;
  return false;
}

ObjectInstanceHandle
InsertObjectInstanceMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

DeleteObjectInstanceMessage::DeleteObjectInstanceMessage() :
  _federationHandle(),
  _federateHandle(),
  _objectInstanceHandle(),
  _tag()
{
}

DeleteObjectInstanceMessage::~DeleteObjectInstanceMessage()
{
}

const char*
DeleteObjectInstanceMessage::getTypeName() const
{
  return "DeleteObjectInstanceMessage";
}

void
DeleteObjectInstanceMessage::out(std::ostream& os) const
{
  os << "DeleteObjectInstanceMessage " << *this;
}

void
DeleteObjectInstanceMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
DeleteObjectInstanceMessage::operator==(const AbstractMessage& rhs) const
{
  const DeleteObjectInstanceMessage* message = dynamic_cast<const DeleteObjectInstanceMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
DeleteObjectInstanceMessage::operator==(const DeleteObjectInstanceMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getTag() != rhs.getTag()) return false;
  return true;
}

bool
DeleteObjectInstanceMessage::operator<(const DeleteObjectInstanceMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  return false;
}

ObjectInstanceHandle
DeleteObjectInstanceMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

TimeStampedDeleteObjectInstanceMessage::TimeStampedDeleteObjectInstanceMessage() :
  _federationHandle(),
  _federateHandle(),
  _objectInstanceHandle(),
  _orderType(),
  _tag(),
  _timeStamp(),
  _messageRetractionHandle()
{
}

TimeStampedDeleteObjectInstanceMessage::~TimeStampedDeleteObjectInstanceMessage()
{
}

const char*
TimeStampedDeleteObjectInstanceMessage::getTypeName() const
{
  return "TimeStampedDeleteObjectInstanceMessage";
}

void
TimeStampedDeleteObjectInstanceMessage::out(std::ostream& os) const
{
  os << "TimeStampedDeleteObjectInstanceMessage " << *this;
}

void
TimeStampedDeleteObjectInstanceMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TimeStampedDeleteObjectInstanceMessage::operator==(const AbstractMessage& rhs) const
{
  const TimeStampedDeleteObjectInstanceMessage* message = dynamic_cast<const TimeStampedDeleteObjectInstanceMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TimeStampedDeleteObjectInstanceMessage::operator==(const TimeStampedDeleteObjectInstanceMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getOrderType() != rhs.getOrderType()) return false;
  if (getTag() != rhs.getTag()) return false;
  if (getTimeStamp() != rhs.getTimeStamp()) return false;
  if (getMessageRetractionHandle() != rhs.getMessageRetractionHandle()) return false;
  return true;
}

bool
TimeStampedDeleteObjectInstanceMessage::operator<(const TimeStampedDeleteObjectInstanceMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getOrderType() < rhs.getOrderType()) return true;
  if (rhs.getOrderType() < getOrderType()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  if (getTimeStamp() < rhs.getTimeStamp()) return true;
  if (rhs.getTimeStamp() < getTimeStamp()) return false;
  if (getMessageRetractionHandle() < rhs.getMessageRetractionHandle()) return true;
  if (rhs.getMessageRetractionHandle() < getMessageRetractionHandle()) return false;
  return false;
}

ObjectInstanceHandle
TimeStampedDeleteObjectInstanceMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

AttributeUpdateMessage::AttributeUpdateMessage() :
  _federationHandle(),
  _federateHandle(),
  _objectInstanceHandle(),
  _tag(),
  _transportationType(),
  _attributeValues()
{
}

AttributeUpdateMessage::~AttributeUpdateMessage()
{
}

const char*
AttributeUpdateMessage::getTypeName() const
{
  return "AttributeUpdateMessage";
}

void
AttributeUpdateMessage::out(std::ostream& os) const
{
  os << "AttributeUpdateMessage " << *this;
}

void
AttributeUpdateMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
AttributeUpdateMessage::operator==(const AbstractMessage& rhs) const
{
  const AttributeUpdateMessage* message = dynamic_cast<const AttributeUpdateMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
AttributeUpdateMessage::operator==(const AttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getTag() != rhs.getTag()) return false;
  if (getTransportationType() != rhs.getTransportationType()) return false;
  if (getAttributeValues() != rhs.getAttributeValues()) return false;
  return true;
}

bool
AttributeUpdateMessage::operator<(const AttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  if (getTransportationType() < rhs.getTransportationType()) return true;
  if (rhs.getTransportationType() < getTransportationType()) return false;
  if (getAttributeValues() < rhs.getAttributeValues()) return true;
  if (rhs.getAttributeValues() < getAttributeValues()) return false;
  return false;
}

bool
AttributeUpdateMessage::getReliable() const
{
  return getTransportationType() == RELIABLE;
}

ObjectInstanceHandle
AttributeUpdateMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

TimeStampedAttributeUpdateMessage::TimeStampedAttributeUpdateMessage() :
  _federationHandle(),
  _federateHandle(),
  _objectInstanceHandle(),
  _tag(),
  _timeStamp(),
  _messageRetractionHandle(),
  _orderType(),
  _transportationType(),
  _attributeValues()
{
}

TimeStampedAttributeUpdateMessage::~TimeStampedAttributeUpdateMessage()
{
}

const char*
TimeStampedAttributeUpdateMessage::getTypeName() const
{
  return "TimeStampedAttributeUpdateMessage";
}

void
TimeStampedAttributeUpdateMessage::out(std::ostream& os) const
{
  os << "TimeStampedAttributeUpdateMessage " << *this;
}

void
TimeStampedAttributeUpdateMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
TimeStampedAttributeUpdateMessage::operator==(const AbstractMessage& rhs) const
{
  const TimeStampedAttributeUpdateMessage* message = dynamic_cast<const TimeStampedAttributeUpdateMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
TimeStampedAttributeUpdateMessage::operator==(const TimeStampedAttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getFederateHandle() != rhs.getFederateHandle()) return false;
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getTag() != rhs.getTag()) return false;
  if (getTimeStamp() != rhs.getTimeStamp()) return false;
  if (getMessageRetractionHandle() != rhs.getMessageRetractionHandle()) return false;
  if (getOrderType() != rhs.getOrderType()) return false;
  if (getTransportationType() != rhs.getTransportationType()) return false;
  if (getAttributeValues() != rhs.getAttributeValues()) return false;
  return true;
}

bool
TimeStampedAttributeUpdateMessage::operator<(const TimeStampedAttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getFederateHandle() < rhs.getFederateHandle()) return true;
  if (rhs.getFederateHandle() < getFederateHandle()) return false;
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  if (getTimeStamp() < rhs.getTimeStamp()) return true;
  if (rhs.getTimeStamp() < getTimeStamp()) return false;
  if (getMessageRetractionHandle() < rhs.getMessageRetractionHandle()) return true;
  if (rhs.getMessageRetractionHandle() < getMessageRetractionHandle()) return false;
  if (getOrderType() < rhs.getOrderType()) return true;
  if (rhs.getOrderType() < getOrderType()) return false;
  if (getTransportationType() < rhs.getTransportationType()) return true;
  if (rhs.getTransportationType() < getTransportationType()) return false;
  if (getAttributeValues() < rhs.getAttributeValues()) return true;
  if (rhs.getAttributeValues() < getAttributeValues()) return false;
  return false;
}

bool
TimeStampedAttributeUpdateMessage::getReliable() const
{
  return getTransportationType() == RELIABLE;
}

ObjectInstanceHandle
TimeStampedAttributeUpdateMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

RequestAttributeUpdateMessage::RequestAttributeUpdateMessage() :
  _federationHandle(),
  _objectInstanceHandle(),
  _attributeHandles(),
  _tag()
{
}

RequestAttributeUpdateMessage::~RequestAttributeUpdateMessage()
{
}

const char*
RequestAttributeUpdateMessage::getTypeName() const
{
  return "RequestAttributeUpdateMessage";
}

void
RequestAttributeUpdateMessage::out(std::ostream& os) const
{
  os << "RequestAttributeUpdateMessage " << *this;
}

void
RequestAttributeUpdateMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
RequestAttributeUpdateMessage::operator==(const AbstractMessage& rhs) const
{
  const RequestAttributeUpdateMessage* message = dynamic_cast<const RequestAttributeUpdateMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
RequestAttributeUpdateMessage::operator==(const RequestAttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getObjectInstanceHandle() != rhs.getObjectInstanceHandle()) return false;
  if (getAttributeHandles() != rhs.getAttributeHandles()) return false;
  if (getTag() != rhs.getTag()) return false;
  return true;
}

bool
RequestAttributeUpdateMessage::operator<(const RequestAttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getObjectInstanceHandle() < rhs.getObjectInstanceHandle()) return true;
  if (rhs.getObjectInstanceHandle() < getObjectInstanceHandle()) return false;
  if (getAttributeHandles() < rhs.getAttributeHandles()) return true;
  if (rhs.getAttributeHandles() < getAttributeHandles()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  return false;
}

ObjectInstanceHandle
RequestAttributeUpdateMessage::getObjectInstanceHandleForMessage() const
{
  return getObjectInstanceHandle();
}

RequestClassAttributeUpdateMessage::RequestClassAttributeUpdateMessage() :
  _federationHandle(),
  _objectClassHandle(),
  _attributeHandles(),
  _tag()
{
}

RequestClassAttributeUpdateMessage::~RequestClassAttributeUpdateMessage()
{
}

const char*
RequestClassAttributeUpdateMessage::getTypeName() const
{
  return "RequestClassAttributeUpdateMessage";
}

void
RequestClassAttributeUpdateMessage::out(std::ostream& os) const
{
  os << "RequestClassAttributeUpdateMessage " << *this;
}

void
RequestClassAttributeUpdateMessage::dispatch(const AbstractMessageDispatcher& dispatcher) const
{
  dispatcher.accept(*this);
}

bool
RequestClassAttributeUpdateMessage::operator==(const AbstractMessage& rhs) const
{
  const RequestClassAttributeUpdateMessage* message = dynamic_cast<const RequestClassAttributeUpdateMessage*>(&rhs);
  if (!message)
    return false;
  return operator==(*message);
}

bool
RequestClassAttributeUpdateMessage::operator==(const RequestClassAttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() != rhs.getFederationHandle()) return false;
  if (getObjectClassHandle() != rhs.getObjectClassHandle()) return false;
  if (getAttributeHandles() != rhs.getAttributeHandles()) return false;
  if (getTag() != rhs.getTag()) return false;
  return true;
}

bool
RequestClassAttributeUpdateMessage::operator<(const RequestClassAttributeUpdateMessage& rhs) const
{
  if (getFederationHandle() < rhs.getFederationHandle()) return true;
  if (rhs.getFederationHandle() < getFederationHandle()) return false;
  if (getObjectClassHandle() < rhs.getObjectClassHandle()) return true;
  if (rhs.getObjectClassHandle() < getObjectClassHandle()) return false;
  if (getAttributeHandles() < rhs.getAttributeHandles()) return true;
  if (rhs.getAttributeHandles() < getAttributeHandles()) return false;
  if (getTag() < rhs.getTag()) return true;
  if (rhs.getTag() < getTag()) return false;
  return false;
}

} // namespace OpenRTI
